package co.com.manuel.gastos.utility.conexionSQL;

import java.util.Date;
import java.util.Vector;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;
import co.com.manuel.gastos.bolsaSaldoDTO.BolsaSaldoDTO;
import co.com.manuel.gastos.detalleSaldoDTO.DetalleSaldoDTO;
import co.com.manuel.gastos.gastoDTO.GastoDTO;
import co.com.manuel.gastos.tipoGastoDTO.TipoGastoDTO;
import co.com.manuel.gastos.tipoSaldoDTO.TipoSaldoDTO;
import co.com.manuel.gastos.usuarioDTO.UsuarioDTO;

/**
 * clase encargada de la gestion con la base de datos, se encarga de insertar actualizar la base de datos.
 * @author manuelhenao
 *
 */


public class ConexionSQLite {

	// tablas
	public static final String TAG = "ConexionLocal";
	public static final String DB_NAME = "bd_gastos";
	public static final String DB_TABLE_TIPO_GASTO = "tipo_gasto";
	public static final String DB_TABLE_GASTO = "gasto";
	public static final String DB_TABLE_BOLSA_SALDO = "bolsa_saldo";
	public static final String DB_TABLE_TIPO_SALDO = "tipo_saldo";
	public static final String DB_TABLE_USUARIO = "usuario";
	public static final String DB_TABLE_DETALLE_SALDO = "detalle_saldo";

	// version de la base de datos
	public static final int DB_VERSION = 1;

	private static final String CLASSNAME = ConexionSQLite.class.getSimpleName();

	// Tablas tipo
	private static final String[] COLS_TIPO_GASTO = new String[] {
			"IdTipoGasto", "TipNombre", "TipDescripcion", "TipActivo" };
	private static final String[] COLS_GASTO = new String[] { 
		    "IdGasto", "IdTipoGasto", "IdBolsaSal", "GasValor", "GasDescripcion", "GasFecha" };
	private static final String[] COLS_BOLSA_SALDO = new String[] {
			"IdBolsaSal", "SalValor", "SalDescripcion", "IdTipoSaldo" , "BolNombre"};
	private static final String[] COLS_TIPO_SALDO = new String[] {
			"IdTipoSaldo", "TipSalNombre", "TipSalDescripcion", "TipSalActivo" };
	private static final String[] COLS_USUARIO = new String[] { 
		    "IdUsuario", "UsuNomUsuario", "UsuClave", "UsuNombres", "UsuApellidos",
			"UsuIsLogueado" };
	private static final String[] COLS_DETALLE_SALDO = new String[] {
			"IdDetalleSaldo", "IdBolsaSal", "DetSalValor", "DetSalTipoMov", "DetFecha" };

	private SQLiteDatabase db;
	private final DBOpenHelper dbOpenHelper;

	/**
	 * clase necesaria para gestionar la conexion a la base de datos tambien la
	 * crea si no exite
	 * 
	 * @author Manuel Henao Cardona
	 * 
	 */
	private static class DBOpenHelper extends SQLiteOpenHelper {

		private static final String DB_CREATE_TIPO_GASTO = "CREATE TABLE "
				+ ConexionSQLite.DB_TABLE_TIPO_GASTO
				+ " (IdTipoGasto INTEGER PRIMARY KEY AUTOINCREMENT, TipNombre TEXT NOT NULL, TipDescripcion TEXT, TipActivo INTEGER NOT NULL);";

		private static final String DB_CREATE_GASTO = "CREATE TABLE "
				+ ConexionSQLite.DB_TABLE_GASTO
				+ " (IdGasto INTEGER PRIMARY KEY AUTOINCREMENT, IdTipoGasto INTEGER NOT NULL,  IdBolsaSal INTEGER NOT NULL, GasValor INTEGER NOT NULL,  GasDescripcion TEXT, GasFecha TEXT NOT NULL);";

		private static final String DB_CREATE_BOLSA_SALDO = "CREATE TABLE "
				+ ConexionSQLite.DB_TABLE_BOLSA_SALDO
				+ " (IdBolsaSal INTEGER PRIMARY KEY AUTOINCREMENT, SalValor INTEGER NOT NULL,  SalDescripcion TEXT, IdTipoSaldo INTEGER NOT NULL), BolNombre TEXT;";

		private static final String DB_CREATE_TIPO_SALDO = "CREATE TABLE "
				+ ConexionSQLite.DB_TABLE_TIPO_SALDO
				+ " (IdBolsaSal INTEGER PRIMARY KEY AUTOINCREMENT, SalValor INTEGER NOT NULL,  SalDescripcion TEXT, IdTipoSaldo INTEGER NOT NULL);";

		private static final String DB_CREATE_USUARIO = "CREATE TABLE "
				+ ConexionSQLite.DB_TABLE_USUARIO
				+ " (IdUsuario INTEGER PRIMARY KEY AUTOINCREMENT, UsuNomUsuario TEXT, UsuClave TEXT NOT NULL, UsuNombres TEXT, UsuApellidos TEXT, UsuIsLogueado INTEGER);";

		private static final String DB_CREATE_DETALLE_SALDO = "CREATE TABLE "
				+ ConexionSQLite.DB_TABLE_DETALLE_SALDO
				+ " (IdDetalleSaldo INTEGER PRIMARY KEY AUTOINCREMENT, IdBolsaSal INTEGER NOT NULL, DetSalValor INTEGER NOT NULL, DetSalTipoMov TEXT, DetFecha TEXT);";

		
		public DBOpenHelper(final Context context) {
			super(context, ConexionSQLite.DB_NAME, null,
					ConexionSQLite.DB_VERSION);
		}

		@Override
		public void onCreate(final SQLiteDatabase db) {
			try {
				// SE CREAN LAS TABLAS
				db.execSQL(DBOpenHelper.DB_CREATE_TIPO_GASTO);
				db.execSQL(DBOpenHelper.DB_CREATE_GASTO);
				db.execSQL(DBOpenHelper.DB_CREATE_BOLSA_SALDO);
				db.execSQL(DBOpenHelper.DB_CREATE_TIPO_SALDO);
				db.execSQL(DBOpenHelper.DB_CREATE_USUARIO);
				db.execSQL(DBOpenHelper.DB_CREATE_DETALLE_SALDO);

			} catch (SQLException e) {
				Log.e(TAG, ConexionSQLite.CLASSNAME, e);
			}
		}

		@Override
		public void onOpen(final SQLiteDatabase db) {
			super.onOpen(db);
			if (!db.isReadOnly()) {
				// habilita las claves foraneas
				db.execSQL("PRAGMA foreign_keys=ON;");
			}
		}

		@Override
		public void onUpgrade(final SQLiteDatabase db, final int oldVersion, final int newVersion) {
			db.execSQL("DROP TABLE IF EXISTS "
					+ ConexionSQLite.DB_TABLE_TIPO_GASTO);
			db.execSQL("DROP TABLE IF EXISTS "
					+ ConexionSQLite.DB_TABLE_GASTO);
			db.execSQL("DROP TABLE IF EXISTS "
					+ ConexionSQLite.DB_TABLE_BOLSA_SALDO);
			db.execSQL("DROP TABLE IF EXISTS "
					+ ConexionSQLite.DB_TABLE_TIPO_SALDO);
			db.execSQL("DROP TABLE IF EXISTS "
					+ ConexionSQLite.DB_TABLE_USUARIO);
			db.execSQL("DROP TABLE IF EXISTS "
					+ ConexionSQLite.DB_TABLE_DETALLE_SALDO);			
			onCreate(db);
		}
	}

	/**
	 * instancia la conexion en el contexto enviado
	 * 
	 * @param context
	 */
	public ConexionSQLite(final Context context) {
		this.dbOpenHelper = new DBOpenHelper(context);
		establishDb();
	}

	/**
	 * Establece la base de datos
	 */
	private void establishDb() {
		try {
			if (this.db == null) {
				this.db = this.dbOpenHelper.getWritableDatabase();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * limpia la referencia a la base de datos
	 */
	public void cleanup() {
		if (this.db != null) {
			this.db.close();
			this.db = null;
		}
	}



	/**
	 * Inserta un tipo de de gasto
	 * 
	 * @param detalle
	 */
	public void insertTipoGasto(final TipoGastoDTO tipoGasto) {
		ContentValues values = new ContentValues();
		//"IdTipoGasto", "TipNombre", "TipDescripcion", "TipActivo"
		values.put("IdTipoGasto", tipoGasto.getIdTipoGasto());
		values.put("TipNombre", tipoGasto.getTipoNombre());
		values.put("TipDescripcion", tipoGasto.getTipDescripcion());
		values.put("TipActivo", tipoGasto.getTipoActivo());
		this.db.insert(ConexionSQLite.DB_TABLE_TIPO_GASTO, null, values);
	}

	/**
	 * Obtiene todas los tipos de gasto
	 * 
	 * @param were, argsWer
	 * @return lista de tipos de gasto
	 */
	public Vector<TipoGastoDTO> getTipoGasto(String were, String[] argsWer) {
		// creamos un vector con los tipos de novedades
		Vector<TipoGastoDTO> tipoGasto = new Vector<TipoGastoDTO>();
		Cursor c = null;
		try {
			c = this.db.query(ConexionSQLite.DB_TABLE_TIPO_GASTO, ConexionSQLite.COLS_TIPO_GASTO, were, argsWer, null, null, null);
			int numRows = c.getCount();
			c.moveToFirst();
			for (int i = 0; i < numRows; ++i) {
				TipoGastoDTO p = new TipoGastoDTO();
				p.setIdTipoGasto(c.getInt(0));
				p.setTipoNombre(c.getString(1));
				p.setTipDescripcion(c.getString(2));
				p.setTipoActivo(Integer.parseInt(c.getString(3)));				
				tipoGasto.add(p);
				c.moveToNext();
			}
		} catch (Exception e) {
			Log.v(TAG, ConexionSQLite.CLASSNAME, e);
		} finally {
			if (c != null && !c.isClosed()) {
				c.close();
			}
		}
		return tipoGasto;
	}

	/**
	 * Inserta un gasto
	 * 
	 * @param gastoDTO
	 */
	
	public void insertGasto(final GastoDTO gasto) {
		ContentValues values = new ContentValues();
		//"IdGasto", "IdTipoGasto", "IdBolsaSal", "GasValor", "GasDescripcion", "GasFecha" 
		values.put("IdGasto", gasto.getIdGasto());
		values.put("IdTipoGasto", gasto.getIdTipoGasto().getIdTipoGasto());
		values.put("IdBolsaSal", gasto.getIdBolsaSal().getIdBolsaSal());
		values.put("GasValor", gasto.getGasValor());
		values.put("GasDescripcion", gasto.getGasDescripcion());
		if(gasto.getGasFecha()==null){
			Date d = new Date();
			values.put("GasFecha", d.getTime());
		}else{
			values.put("GasFecha", gasto.getGasFecha().getTime());
		}	
		this.db.insert(ConexionSQLite.DB_TABLE_GASTO, null, values);
	}

	/**
	 * Obtiene todos los gastos
	 * 
	 * @return lista de gastos
	 */
	public Vector<GastoDTO> getGasto() {
		// creamos un vector con los tipos de novedades
		Vector<GastoDTO> gasto = new Vector<GastoDTO>();
		Cursor c = null;
		try {
			c = this.db.query(ConexionSQLite.DB_TABLE_GASTO, ConexionSQLite.COLS_GASTO, null, null, null, null, null);
			int numRows = c.getCount();
			c.moveToFirst();
			for (int i = 0; i < numRows; ++i) {
				GastoDTO p = new GastoDTO();
				//"IdGasto", "IdTipoGasto", "IdBolsaSal", "GasValor", "GasDescripcion", "GasFecha" 
				p.setIdGasto(c.getInt(0));
				//guardo el id de gasto para poder consultar su tipo gasto 
				int idTipoGasto = c.getInt(1);
				String[] argsWer2 = new String[] {Integer.toString(idTipoGasto)};
				//consulto el tipo de gasto asociado al gasto
				TipoGastoDTO tipogastoDto = getTipoGasto("IdTipoGasto = ?", argsWer2).get(0);
				p.setIdTipoGasto(tipogastoDto);	
				//guardo el id del tipo del saldo para poder consultar el tipo de saldo
				int idBolsaSal = c.getInt(2);
				String[] argsWer3 = new String[] {Integer.toString(idBolsaSal)};
				//consulto el tipo de saldo
                BolsaSaldoDTO  bolsaSaldoDTO = getBolsaSaldoDTO("IdBolsaSal = ?", argsWer3).get(0);
                p.setIdBolsaSal(bolsaSaldoDTO);
                p.setGasValor(c.getDouble(3));
                p.setGasDescripcion(c.getString(4));
                Date fechaGasto = new Date();
                fechaGasto.setTime(c.getInt(5));
                p.setGasFecha(fechaGasto);
				gasto.add(p);
				c.moveToNext();
			}
		} catch (Exception e) {
			Log.v(TAG, ConexionSQLite.CLASSNAME, e);
		} finally {
			if (c != null && !c.isClosed()) {
				c.close();
			}
		}
		return gasto;
	}

	/**
	 * Inserta un tipo de saldo
	 * 
	 * @param detalle
	 */
	public void inserTipoSaldo(final TipoSaldoDTO tipoSaldoDTO) {
		ContentValues values = new ContentValues();
		//IdTipoSaldo", "TipSalNombre", "TipSalDescripcion", "TipSalActivo"
		values.put("IdTipoSaldo", tipoSaldoDTO.getIdTipoSaldo());
		values.put("TipSalNombre", tipoSaldoDTO.getTipSalNombre());
		values.put("TipSalDescripcion", tipoSaldoDTO.getTipSalDescripcion());
		values.put("TipSalActivo", tipoSaldoDTO.getTipSalActivo());
		this.db.insert(ConexionSQLite.DB_TABLE_TIPO_SALDO, null, values);
	}

	/**
	 * Obtiene los tipos de saldo
	 * 
	 * @return lista de tipos de saldo
	 */
	public Vector<TipoSaldoDTO> getTipoEntidadSede(String were, String[] argsWer) {

		// creamos un vector con los tipos de saldo
		Vector<TipoSaldoDTO> tipoSaldoDTO = new Vector<TipoSaldoDTO>();
		Cursor c = null;
		try {
			c = this.db.query(ConexionSQLite.DB_TABLE_TIPO_SALDO, ConexionSQLite.COLS_TIPO_SALDO, were, argsWer, null, null, null);
			int numRows = c.getCount();
			c.moveToFirst();
			for (int i = 0; i < numRows; ++i) {
				TipoSaldoDTO p = new TipoSaldoDTO();
				//"IdTipoSaldo", "TipSalNombre", "TipSalDescripcion", "TipSalActivo"
				p.setIdTipoSaldo(c.getInt(0));
				p.setTipSalNombre(c.getString(1));
				p.setTipSalDescripcion(c.getString(2));
				p.setTipSalActivo(c.getInt(3));
				tipoSaldoDTO.add(p);
				c.moveToNext();
			}
		} catch (Exception e) {
			Log.v(TAG, ConexionSQLite.CLASSNAME, e);
		} finally {
			if (c != null && !c.isClosed()) {
				c.close();
			}
		}
		return tipoSaldoDTO;
	}

	/**
	 * Inserta un usuario
	 * 
	 * @param usuarioDTO
	 */
	public void inserUsuario(final UsuarioDTO usuarioDTO) {
		ContentValues values = new ContentValues();
		//"IdUsuario", "UsuNomUsuario", "UsuClave", "UsuNombres", "UsuApellidos", "UsuIsLogueado"
		values.put("IdUsuario", usuarioDTO.getIdUsuario());
		values.put("UsuNomUsuario", usuarioDTO.getUsuNombres());
		values.put("UsuClave", usuarioDTO.getUsuClave());
		values.put("UsuNombres", usuarioDTO.getUsuNombres());
		values.put("UsuApellidos", usuarioDTO.getUsuApellidos());
		values.put("UsuIsLogueado", usuarioDTO.getUsuIsLogueado());
		this.db.insert(ConexionSQLite.DB_TABLE_USUARIO, null, values);
	}


	/**
	 * Obtiene el Usuario de la aplicacion
	 * 
	 * @return  UsuarioDTO
	 */
	public UsuarioDTO getUsuario() {
		// creamos una instancia de UsuarioDTO
		UsuarioDTO usuarioDTO = new UsuarioDTO();
		Cursor c = null;
		try {
			//"IdUsuario", "UsuNomUsuario", "UsuClave", "UsuNombres", "UsuApellidos", "UsuIsLogueado"
			c = this.db.query(ConexionSQLite.DB_TABLE_USUARIO, ConexionSQLite.COLS_USUARIO, null, null,	null, null, null);
			c.moveToFirst();
			usuarioDTO.setIdUsuario(c.getInt(0));
			usuarioDTO.setUsuNombreUsuario(c.getString(1));
			usuarioDTO.setUsuClave(c.getString(2));
			usuarioDTO.setUsuNombres(c.getString(3));
			usuarioDTO.setUsuApellidos(c.getString(4));
			usuarioDTO.setUsuIsLogueado(c.getInt(5));		
		} catch (Exception e) {
			Log.v(TAG, ConexionSQLite.CLASSNAME, e);
		} finally {
			if (c != null && !c.isClosed()) {
				c.close();
			}
		}
		return usuarioDTO;
	}

	/**
	 * Inserta un tipo de saldo
	 * 
	 * @param tipoSaldoDTO
	 */
	public void insertTipoSaldo(final TipoSaldoDTO tipoSaldoDTO) {
		ContentValues values = new ContentValues();
		//"IdTipoSaldo", "TipSalNombre", "TipSalDescripcion", "TipSalActivo"
		values.put("IdTipoSaldo", tipoSaldoDTO.getIdTipoSaldo());
		values.put("TipSalNombre", tipoSaldoDTO.getTipSalNombre());
		values.put("TipSalDescripcion", tipoSaldoDTO.getTipSalDescripcion());
		values.put("TipSalActivo", tipoSaldoDTO.getTipSalActivo());
		this.db.insert(ConexionSQLite.DB_TABLE_TIPO_SALDO, null, values);
	}

	/**
	 * Obtiene todas los tipos de saldo
	 * 
	 * @return lista de tipo saldo
	 */
	public Vector<TipoSaldoDTO> getTipoSaldoDTO(String were, String[] argsWer) {
		// creamos un vector con los tipos de saldo
		Vector<TipoSaldoDTO> tipoSaldoDTO = new Vector<TipoSaldoDTO>();
		Cursor c = null;
		try {
			//"IdTipoSaldo", "TipSalNombre", "TipSalDescripcion", "TipSalActivo"
			c = this.db.query(ConexionSQLite.DB_TABLE_TIPO_SALDO, ConexionSQLite.COLS_TIPO_SALDO, were, argsWer, null, null, null);
			int numRows = c.getCount();
			c.moveToFirst();
			for (int i = 0; i < numRows; ++i) {
				TipoSaldoDTO p = new TipoSaldoDTO();
				p.setIdTipoSaldo(c.getInt(0));
				p.setTipSalNombre(c.getString(1));
				p.setTipSalDescripcion(c.getString(2));
				p.setTipSalActivo(c.getInt(3));
				tipoSaldoDTO.add(p);
				c.moveToNext();
			}
		} catch (Exception e) {
			Log.v(TAG, ConexionSQLite.CLASSNAME, e);
		} finally {
			if (c != null && !c.isClosed()) {
				c.close();
			}
		}
		return tipoSaldoDTO;
	}

	/**
	 * Inserta un saldo a la bolsa
	 * 
	 * @param BolsaSaldoDTO
	 */
	public void insertBolsaSaldo(final BolsaSaldoDTO bolsaSaldoDTO) {
		ContentValues values = new ContentValues();
		//"IdBolsaSal", "SalValor", "SalDescripcion", "IdTipoSaldo", "BolNombre"
		values.put("IdBolsaSal", bolsaSaldoDTO.getIdBolsaSal());
		values.put("SalValor", bolsaSaldoDTO.getSalValor());
		values.put("SalDescripcion", bolsaSaldoDTO.getSalDescripcion());
		values.put("IdTipoSaldo", bolsaSaldoDTO.getIdTipoSaldo().getIdTipoSaldo());	
		values.put("BolNombre", bolsaSaldoDTO.getBolNombre());
		this.db.insert(ConexionSQLite.DB_TABLE_BOLSA_SALDO, null, values);
	}

	/**
	 * Obtiene todos los saldos de las bolsas
	 * 
	 * @return BolsaSaldoDTO
	 */
	public Vector<BolsaSaldoDTO> getBolsaSaldoDTO(String were, String[] argsWer) {
		// creamos un vector con los gastos
		Vector<BolsaSaldoDTO> bolsaSaldoDTO = new Vector<BolsaSaldoDTO>();
		Cursor c = null;
		try {
			//"IdBolsaSal", "SalValor", "SalDescripcion", "IdTipoSaldo" , "BolNombre"
			c = this.db.query(ConexionSQLite.DB_TABLE_BOLSA_SALDO, ConexionSQLite.COLS_BOLSA_SALDO, were, argsWer, null, null, null);
			int numRows = c.getCount();
			c.moveToFirst();
			for (int i = 0; i < numRows; ++i) {
				BolsaSaldoDTO p = new BolsaSaldoDTO();
				p.setIdBolsaSal(c.getInt(0));
				p.setSalValor(c.getDouble(1));
				p.setSalDescripcion(c.getString(2));
				//guardo el id de la bolsa para poder consultar el tipo de saldo que tiene esa bolsa en especifico.
				String[] argsWerTipoSaldo = {""+ c.getInt(3)};
				//consulto el tipo de saldo
				Vector<TipoSaldoDTO> tipoSaldoDTO = getTipoSaldoDTO("IdTipoSaldo = ?",  argsWerTipoSaldo);
				//guardo el DTO de tipo de saldo en el DTO de la bolsa
				p.setIdTipoSaldo(tipoSaldoDTO.get(0));
				p.setBolNombre(c.getString(4));
				bolsaSaldoDTO.add(p);
				c.moveToNext();
			}
		} catch (Exception e) {
			Log.v(TAG, ConexionSQLite.CLASSNAME, e);
		} finally {
			if (c != null && !c.isClosed()) {
				c.close();
			}
		}
		return bolsaSaldoDTO;
	}
	
	/**
	 * Inserta un detalle de saldo de una bolsa
	 * 
	 * @param BolsaSaldoDTO
	 */
	public void insertDetalleSaldo(final DetalleSaldoDTO detalleSaldoDTO) {
		ContentValues values = new ContentValues();
		//"IdDetalleSaldo", "IdBolsaSal", "DetSalValor", "DetSalTipoMov", "DetFecha" 
		values.put("IdDetalleSaldo", detalleSaldoDTO.getIdDetalleSaldo());
		values.put("IdBolsaSal", detalleSaldoDTO.getIdBolsaSal().getIdBolsaSal());
		values.put("DetSalValor", detalleSaldoDTO.getDetSalValor());
		values.put("DetSalTipoMov", detalleSaldoDTO.getDetTipoMov());
		if(detalleSaldoDTO.getDetFecha()==null){
			Date d = new Date();
			values.put("DetFecha", d.getTime());
		}else{
			values.put("DetFecha", detalleSaldoDTO.getDetFecha().getTime());
		}			
		this.db.insert(ConexionSQLite.DB_TABLE_DETALLE_SALDO, null, values);
	}
	/**
	 * Obtiene todas los tipos de saldo
	 * 
	 * @return lista de tipo saldo
	 */
	public Vector<DetalleSaldoDTO> getDetalleSaldoDTO(String were, String[] argsWer) {
		// creamos un vector con los tipos de saldo
		Vector<DetalleSaldoDTO> detalleSaldoDTO = new Vector<DetalleSaldoDTO>();
		Cursor c = null;
		try {
			//"IdDetalleSaldo", "IdBolsaSal", "DetSalValor", "DetSalTipoMov", "DetFecha" 
			c = this.db.query(ConexionSQLite.DB_TABLE_DETALLE_SALDO, ConexionSQLite.COLS_DETALLE_SALDO, were, argsWer, null, null, null);
			int numRows = c.getCount();
			c.moveToFirst();
			for (int i = 0; i < numRows; ++i) {
				DetalleSaldoDTO p = new DetalleSaldoDTO();
				p.setIdDetalleSaldo(c.getInt(0));				
				//guardo el id de la bolsa para poder consultar el detalle de esa bolsa en especifico.
				String[] argsWerBolsaSaldo = {""+ c.getInt(1)};
				//consulto la bolsa saldo
				Vector<BolsaSaldoDTO> tipoSaldoDTO = getBolsaSaldoDTO("IdBolsaSaldoDTO = ?",  argsWerBolsaSaldo);
				p.setIdBolsaSal(tipoSaldoDTO.get(0));
				p.setDetSalValor(c.getDouble(2));
				p.setDetTipoMov(c.getString(3));
				// fecha
				Date detFecha = new Date();
				detFecha.setTime(c.getInt(4));
                p.setDetFecha(detFecha);
            	detalleSaldoDTO.add(p);
				c.moveToNext();
			}
		} catch (Exception e) {
			Log.v(TAG, ConexionSQLite.CLASSNAME, e);
		} finally {
			if (c != null && !c.isClosed()) {
				c.close();
			}
		}
		return detalleSaldoDTO;
	}
}
